{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Рецепты"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "\n",
    "\n",
    "def make_translation(source, target):\n",
    "    assert len(source) == len(target)\n",
    "    return {\n",
    "        ord(a): ord(b)\n",
    "        for a, b in zip(source, target)\n",
    "    }\n",
    "\n",
    "\n",
    "DASHES_TRANSLATION = make_translation(\n",
    "    '‑–—−',\n",
    "    '----'\n",
    ")\n",
    "\n",
    "\n",
    "def preprocess(text):\n",
    "    text = text.replace('\\xa0', ' ')\n",
    "    text = text.replace('\\xad', '')\n",
    "    text = text.translate(DASHES_TRANSLATION)\n",
    "    return text\n",
    "\n",
    "\n",
    "texts = []\n",
    "for path in sorted(glob('texts/*.txt')):\n",
    "    with open(path) as file:\n",
    "        text = file.read()\n",
    "        text = preprocess(text)\n",
    "        texts.append(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Мексиканский суп с курицей\n",
      "\n",
      "Нам потребуется:\n",
      "\n",
      "Куриная грудка - 1 шт.,\n",
      "Лук репчатый - 1 шт.,\n",
      "Красная фасоль консервированная - 1 банка,\n",
      "Вермишель - 50 г,\n",
      "Кукуруза замороженная - 100 г,\n",
      "Укроп - по вкусу,\n",
      "Соль - по вкусу,\n",
      "Молотый острый красный перец - по вкусу.\n",
      "\n",
      "Из куриной грудки сварите бульон, достаньте мясо, отделите от костей и мелко нарежьте.\n",
      "\n",
      "Лук мелко нашинкуйте. В глубоком сотейнике разогрейте растительное масло и обжарьте лук до прозрачности.\n",
      "\n",
      "Добавьте к луку курицу и обжаривайте несколько минут. С фасоли слейте жидкость. Переложите фасоль в сотейник, добавьте молотый перец по вкусу, перемешайте и продолжайте обжаривать.\n",
      "\n",
      "Залейте в сотейник куриный бульон, посолите по вкусу и варите 5 мин. Добавьте вермишель и кукурузу, варите еще 5 минут, затем накройте крышкой и снимите с огня.\n",
      "\n",
      "Дайте супу настояться. Мелко нарубите укроп. Подавайте суп с укропом и кукурузными чипсами.\n",
      "------------------------------\n",
      "Мясной пирог\n",
      "\n",
      "Ингредиенты:\n",
      "для теста:\n",
      "сливочное масло - 1/2 стак\n",
      "сметана - 1 стак\n",
      "яйцо - 1 шт\n",
      "сода для выпечки - 1/4 ч.л\n",
      "соль - 1/4 ч.л.\n",
      "мука - 2,5 стак\n",
      "\n",
      "для начинки:\n",
      "баранина - 450 гр\n",
      "луковица - 2 шт\n",
      "картофель - 2 шт\n",
      "соль - 1 ч.л.\n",
      "черный перец - 1/2 ч.л.\n",
      "кумин - 1/2 ч.л.\n",
      "яйцо - 1 шт\n",
      "\n",
      "Приготовление:\n",
      "- В средней миске смешать растопленное сливочное масло, сметану, 1 яйцо, порошок для выпечки и соль.\n",
      "- Добавить первые 2 стакана муки и посмотреть, можно ли замесить очень мягкое тесто, которое не будет прилипать к рукам или к стенкам миски.\n",
      "- Если этого не достаточно, добавить оставшуюся муку и продолжать месить.\n",
      "- Разделить тесто на 2 части. Одна часть должна быть немного меньше, чем другая. Оберните их полиэтиленовой пленкой и отложите в сторону.\n",
      "- Разогреть духовку до 375F.\n",
      "- Тонко покрошить лук.\n",
      "- Нарежьте мясо и картофель на маленькие кубики. Добавьте специи и все хорошенько перемешайте.\n",
      "- Раскатайте большую часть теста на листе для выпечки, предварительно посыпав его мукой.\n",
      "- Наполняем пирог начинкой. Оставьте немного места по краям.\n",
      "- Закрываем начинку второй частью теста, запечатываем края.\n",
      "- Смешиваем яйцо с небольшим количеством воды и промазываем кисточкой верхнюю часть пирога.\n",
      "- Сделайте небольшие надрезы. Выпекайте пирог до золотистого цвета.\n",
      "------------------------------\n"
     ]
    }
   ],
   "source": [
    "from random import seed, sample\n",
    "\n",
    "seed(40)\n",
    "for text in sample(texts, 2):\n",
    "    print(text)\n",
    "    print('---' * 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "\n",
    "def find_ingredient_sections(text):\n",
    "    return re.findall(r'ингредиенты:(.+?)приготовление', text, re.I | re.S)\n",
    "\n",
    "\n",
    "def maybe_ingredient(line):\n",
    "    match = re.search(r'\\d', line)\n",
    "    size = len(line) <= 50\n",
    "    return match and size\n",
    "\n",
    "\n",
    "lines = []\n",
    "for text in texts:\n",
    "    sections = find_ingredient_sections(text)\n",
    "    for section in sections:\n",
    "        for line in section.splitlines():\n",
    "            if maybe_ingredient(line):\n",
    "                lines.append(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['● Оливковое масло - 2 ст. л.',\n",
       " 'Молоко 1% - 100 г ',\n",
       " '- Морковь 2 - 3 шт.',\n",
       " 'творог - 500 г,',\n",
       " '2 яйца,',\n",
       " '* 3/4 стакана холодной кипяченой воды',\n",
       " '• сыр - 100 г.',\n",
       " '1 нарезанный красный перец',\n",
       " '230 г кокосового или тростникового сахара ',\n",
       " 'Яйцо - 3 шт.',\n",
       " 'Сок лайма - 2 Ст. ложки',\n",
       " '● Мука - 100 г.',\n",
       " 'Сметана - 50 г',\n",
       " '● Бананы - 3 шт.',\n",
       " 'ананасы консервированные - 1 банка ',\n",
       " '● Сыр твердый 30 гр.',\n",
       " '500 мл растительного масла ',\n",
       " '5) соль, растительное масло для пассеровки овощей.',\n",
       " '5 средних варёных картофелин ',\n",
       " '● 3-5 зубчиков чеснока; ']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed(14)\n",
    "sample(lines, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Grammar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display\n",
    "\n",
    "# pip install ipymarkup\n",
    "from ipymarkup import show_span_ascii_markup as show_markup\n",
    "\n",
    "from yargy import (\n",
    "    Parser,\n",
    "    or_, rule\n",
    ")\n",
    "from yargy.pipelines import morph_pipeline\n",
    "from yargy.predicates import (\n",
    "    eq, in_, dictionary,\n",
    "    type, gram\n",
    ")\n",
    "from yargy.tokenizer import MorphTokenizer\n",
    "from yargy import interpretation as interp\n",
    "from yargy.interpretation import fact, attribute\n",
    "\n",
    "\n",
    "def show_matches(rule, *lines):\n",
    "    parser = Parser(rule)\n",
    "    for line in lines:\n",
    "        matches = parser.findall(line)\n",
    "        matches = sorted(matches, key=lambda _: _.span)\n",
    "        spans = [_.span for _ in matches]\n",
    "        show_markup(line, spans)\n",
    "        if matches:\n",
    "            facts = [_.fact for _ in matches]\n",
    "            if len(facts) == 1:\n",
    "                facts = facts[0]\n",
    "            display(facts)\n",
    "\n",
    "\n",
    "INT = type('INT')\n",
    "NOUN = gram('NOUN')\n",
    "ADJF = gram('ADJF')\n",
    "PRTF = gram('PRTF')\n",
    "GENT = gram('gent')\n",
    "DOT = eq('.')\n",
    "\n",
    "TOKENIZER = MorphTokenizer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Spoon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 Ст. ложки\n",
      "  ─────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Spoon(\n",
       "    type='столовая'\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 чайных л\n",
      "  ────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Spoon(\n",
       "    type='чайная'\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Spoon = fact(\n",
    "    'Spoon',\n",
    "    ['type']\n",
    ")\n",
    "\n",
    "\n",
    "TEA = morph_pipeline([\n",
    "    'ч',\n",
    "    'чайн',\n",
    "    'чайная',\n",
    "]).interpretation(\n",
    "    Spoon.type.const('чайная')\n",
    ")\n",
    "\n",
    "TABLE = morph_pipeline([\n",
    "    'ст',\n",
    "    'стол',\n",
    "    'столовая',\n",
    "]).interpretation(\n",
    "    Spoon.type.const('столовая')\n",
    ")\n",
    "\n",
    "NAME = morph_pipeline([\n",
    "    'л',\n",
    "    'ложка'\n",
    "])\n",
    "\n",
    "SPOON = rule(\n",
    "    or_(TEA, TABLE),\n",
    "    DOT.optional(),\n",
    "    NAME,\n",
    "    DOT.optional()\n",
    ").interpretation(\n",
    "    Spoon\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    SPOON,\n",
    "    '2 Ст. ложки',\n",
    "    '3 чайных л',\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 стак.\n",
      "  ─────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Unit(\n",
       "    type='стакан',\n",
       "    modifier=None\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/2 небольшой чайной ложки\n",
      "              ────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Unit(\n",
       "    type=Spoon(\n",
       "        type='чайная'\n",
       "    ),\n",
       "    modifier=None\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "по 1 килограмму\n",
      "     ──────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Unit(\n",
       "    type='килограмм',\n",
       "    modifier=None\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "штука\n",
      "─────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Unit(\n",
       "    type='штука',\n",
       "    modifier=None\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ложечку\n",
      "огромная упаковка\n",
      "         ────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Unit(\n",
       "    type='упаковка',\n",
       "    modifier=None\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from yargy.record import Record\n",
    "\n",
    "\n",
    "Unit = fact(\n",
    "    'Unit',\n",
    "    ['type', 'modifier']\n",
    ")\n",
    "\n",
    "\n",
    "class Synonyms(Record):\n",
    "    __attributes__ = ['name', 'synonyms']\n",
    "    \n",
    "    def __init__(self, name, synonyms=()):\n",
    "        self.name = name\n",
    "        self.synonyms = synonyms\n",
    "\n",
    "\n",
    "NAMES = [\n",
    "    Synonyms('банка', ['бан']),\n",
    "    Synonyms('грамм', ['г', 'гр']),\n",
    "    Synonyms('горсть'),\n",
    "    Synonyms('зубчик'),\n",
    "    Synonyms('килограмм', ['кг']),\n",
    "    Synonyms('литр', ['л']),\n",
    "    Synonyms('миллиграмм', ['мг']),\n",
    "    Synonyms('миллилитр', ['мл']),\n",
    "    Synonyms('пакетик'),\n",
    "    Synonyms('полоска'),\n",
    "    Synonyms('пучок', ['пуч']),\n",
    "    Synonyms('сантиметр', ['см']),\n",
    "    Synonyms('стакан', ['чашка', 'стак', 'ст']),\n",
    "    Synonyms('стебель'),\n",
    "    Synonyms('упаковка', ['уп', 'пачка']),\n",
    "    Synonyms('штука', ['шт']),\n",
    "    Synonyms('щепотка'),\n",
    "]\n",
    "\n",
    "\n",
    "names = []\n",
    "mapping = {}\n",
    "for record in NAMES:\n",
    "    name = record.name\n",
    "    names.append(name)\n",
    "    mapping[name] = name\n",
    "    for synonym in record.synonyms:\n",
    "        names.append(synonym)\n",
    "        mapping[synonym] = name\n",
    "\n",
    "\n",
    "NAME = morph_pipeline(names).interpretation(\n",
    "    Unit.type.normalized().custom(mapping.get)\n",
    ")\n",
    "\n",
    "NAME = rule(\n",
    "    NAME,\n",
    "    DOT.optional()\n",
    ")\n",
    "\n",
    "MODIFIER = morph_pipeline([\n",
    "    'маленький',\n",
    "    'большой',\n",
    "    'неполный',\n",
    "    'средний',\n",
    "    'средне большой',\n",
    "]).interpretation(\n",
    "    Unit.modifier.normalized()\n",
    ")\n",
    "\n",
    "UNIT = rule(\n",
    "    MODIFIER.optional(),\n",
    "    or_(\n",
    "        NAME,\n",
    "        SPOON.interpretation(\n",
    "            Unit.type\n",
    "        )\n",
    "    )\n",
    ").interpretation(\n",
    "    Unit\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    UNIT,\n",
    "    '1 стак.',\n",
    "    '1/2 небольшой чайной ложки',\n",
    "    'по 1 килограмму',\n",
    "    'штука',\n",
    "    'ложечку',\n",
    "    'огромная упаковка'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Amount"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~ 3,14\n",
      "  ────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3.14"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.1$\n",
      "──── \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "35.1"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "15\n",
      "──\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45.3\n",
      "── ─\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[45, 3]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def normalize_float(value):\n",
    "    value = re.sub('[\\s,.]+', '.', value)\n",
    "    return float(value)\n",
    "\n",
    "\n",
    "FLOAT = rule(\n",
    "    INT,\n",
    "    in_('.,'),\n",
    "    INT\n",
    ").interpretation(\n",
    "    interp.custom(normalize_float)\n",
    ")\n",
    "\n",
    "DIGIT = INT.interpretation(\n",
    "    interp.custom(int)\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    FLOAT,\n",
    "    '~ 3,14',\n",
    "    '35.1$',\n",
    "    '13'\n",
    ")\n",
    "show_matches(\n",
    "    DIGIT,\n",
    "    '15',\n",
    "    '45.3'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\\2\n",
      "───\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Fraction(\n",
       "    numerator=1,\n",
       "    denominator=2\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/3\n",
      "───\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Fraction(\n",
       "    numerator=1,\n",
       "    denominator=3\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "½\n",
      "─\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Fraction(\n",
       "    numerator=1,\n",
       "    denominator=2\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Fraction = fact(\n",
    "    'Fraction',\n",
    "    ['numerator', 'denominator']\n",
    ")\n",
    "\n",
    "\n",
    "NUMERATOR = INT.interpretation(\n",
    "    Fraction.numerator.custom(int)\n",
    ")\n",
    "\n",
    "DENOMINATOR = INT.interpretation(\n",
    "    Fraction.denominator.custom(int)\n",
    ")\n",
    "\n",
    "FRACTION = rule(\n",
    "    NUMERATOR,\n",
    "    in_('/\\\\'),\n",
    "    DENOMINATOR\n",
    ").interpretation(\n",
    "    Fraction\n",
    ")\n",
    "\n",
    "UNICODES = {\n",
    "    '½': Fraction(numerator=1, denominator=2),\n",
    "    '⅓': Fraction(numerator=1, denominator=3),\n",
    "    '⅔': Fraction(numerator=2, denominator=3),\n",
    "    '¼': Fraction(numerator=1, denominator=4),\n",
    "    '¾': Fraction(numerator=3, denominator=4)\n",
    "}\n",
    "\n",
    "UNICODE = in_(UNICODES).interpretation(\n",
    "    interp.custom(UNICODES.get)\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    FRACTION,\n",
    "    r'1\\2',\n",
    "    '1/3'\n",
    ")\n",
    "show_matches(\n",
    "    UNICODE,\n",
    "    '½'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Literal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "без двух\n",
      "    ────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "один, два\n",
      "────  ───\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "LITERALS = {\n",
    "    'один': 1,\n",
    "    'два': 2,\n",
    "    'три': 3\n",
    "}\n",
    "\n",
    "LITERAL = dictionary(LITERALS).interpretation(\n",
    "    interp.normalized().custom(LITERALS.get)\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    LITERAL,\n",
    "    'без двух',\n",
    "    'один, два'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "немного\n",
      "───────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Some()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Some = fact('Some', [])\n",
    "\n",
    "\n",
    "SOME = morph_pipeline([\n",
    "    'по вкусу',\n",
    "    'немного',\n",
    "    'несколько',\n",
    "]).interpretation(\n",
    "    Some\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    SOME,\n",
    "    'немного'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100-110\n",
      "───────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Range(\n",
       "    start=100,\n",
       "    stop=110\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/3-1/2\n",
      "───────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Range(\n",
       "    start=Fraction(\n",
       "        numerator=1,\n",
       "        denominator=3\n",
       "    ),\n",
       "    stop=Fraction(\n",
       "        numerator=1,\n",
       "        denominator=2\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Range = fact(\n",
    "    'Range',\n",
    "    ['start', 'stop']\n",
    ")\n",
    "\n",
    "\n",
    "VALUE = or_(\n",
    "    DIGIT,\n",
    "    UNICODE,\n",
    "    FRACTION,\n",
    "    FLOAT,\n",
    "    LITERAL\n",
    ")\n",
    "\n",
    "\n",
    "RANGE = rule(\n",
    "    VALUE.interpretation(Range.start),\n",
    "    '-',\n",
    "    VALUE.interpretation(Range.stop)\n",
    ").interpretation(\n",
    "    Range\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    RANGE,\n",
    "    '100-110',\n",
    "    '1/3-1/2',\n",
    "    \n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "один-два\n",
      "────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Amount(\n",
       "    value=Range(\n",
       "        start=1,\n",
       "        stop=2\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0,3\n",
      "───\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Amount(\n",
       "    value=0.3\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Amount = fact(\n",
    "    'Amount',\n",
    "    ['value']\n",
    ")\n",
    "\n",
    "\n",
    "AMOUNT = or_(\n",
    "    VALUE,\n",
    "    RANGE,\n",
    "    SOME\n",
    ").interpretation(\n",
    "    Amount.value\n",
    ").interpretation(\n",
    "    Amount\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    AMOUNT,\n",
    "    'один-два',\n",
    "    '0,3'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Measure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 неполных столовых ложки\n",
      "─────────────────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Measure(\n",
       "    amount=Amount(\n",
       "        value=2\n",
       "    ),\n",
       "    unit=Unit(\n",
       "        type=Spoon(\n",
       "            type='столовая'\n",
       "        ),\n",
       "        modifier='неполный'\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 кг\n",
      "────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Measure(\n",
       "    amount=Amount(\n",
       "        value=1\n",
       "    ),\n",
       "    unit=Unit(\n",
       "        type='килограмм',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2-3 дольки\n",
      "───       \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Measure(\n",
       "    amount=Amount(\n",
       "        value=Range(\n",
       "            start=2,\n",
       "            stop=3\n",
       "        )\n",
       "    ),\n",
       "    unit=None\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Measure = fact(\n",
    "    'Measure',\n",
    "    ['amount', 'unit']\n",
    ")\n",
    "\n",
    "\n",
    "MEASURE = rule(\n",
    "    AMOUNT.interpretation(\n",
    "        Measure.amount\n",
    "    ),\n",
    "    UNIT.interpretation(\n",
    "        Measure.unit\n",
    "    ).optional(),\n",
    ").interpretation(\n",
    "    Measure\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    MEASURE,\n",
    "    '2 неполных столовых ложки',\n",
    "    '1 кг',\n",
    "    '2-3 дольки'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "Product = fact(\n",
    "    'Product',\n",
    "    ['name', 'modifier']\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ириска',\n",
       " 'шелуха',\n",
       " 'вишнёвка',\n",
       " 'майоран',\n",
       " 'закваска',\n",
       " 'торт',\n",
       " 'сок',\n",
       " 'сушка',\n",
       " 'пудра',\n",
       " 'крахмал']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = []\n",
    "with open('names.txt') as file:\n",
    "    for line in file:\n",
    "        name = line.rstrip()\n",
    "        names.append(name)\n",
    "\n",
    "\n",
    "seed(1)\n",
    "sample(names, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Горчица\n",
      "───────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'горчица'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "табак\n",
      "солью\n",
      "─────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'соль'"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "NAME = morph_pipeline(names).interpretation(\n",
    "    Product.name.normalized()\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    NAME,\n",
    "    'Горчица',\n",
    "    'табак',\n",
    "    'солью'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15% сметана\n",
      "───        \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Percent(\n",
       "    value=15\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сушеный розмарин\n",
      "───────         \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Adjs(\n",
       "    parts=['сушёный']\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сладкий красный перец\n",
      "───────────────      \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Adjs(\n",
       "    parts=['сладкий',\n",
       "     'красный']\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Percent = fact(\n",
    "    'Percent',\n",
    "    ['value']\n",
    ")\n",
    "Adjs = fact(\n",
    "    'Adjs',\n",
    "    [attribute('parts').repeatable()]\n",
    ")\n",
    "\n",
    "\n",
    "\n",
    "PERCENT = rule(\n",
    "    VALUE.interpretation(Percent.value),\n",
    "    '%'\n",
    ").interpretation(\n",
    "    Percent\n",
    ")\n",
    "\n",
    "ADJ = or_(\n",
    "    ADJF,\n",
    "    PRTF,\n",
    ").interpretation(\n",
    "    interp.normalized()\n",
    ").interpretation(\n",
    "    Adjs.parts\n",
    ")\n",
    "\n",
    "ADJS = ADJ.repeatable(max=3).interpretation(\n",
    "    Adjs\n",
    ")\n",
    "\n",
    "MODIFIER = or_(\n",
    "    ADJS,\n",
    "    PERCENT\n",
    ").interpretation(\n",
    "    Product.modifier\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    MODIFIER,\n",
    "    '15% сметана',\n",
    "    'Сушеный розмарин',\n",
    "    'сладкий красный перец'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "картофель отварной\n",
      "──────────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Product(\n",
       "    name='картофель',\n",
       "    modifier=Adjs(\n",
       "        parts=['отварный']\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сливочное масло\n",
      "───────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Product(\n",
       "    name='масло',\n",
       "    modifier=Adjs(\n",
       "        parts=['сливочный']\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "творог\n",
      "──────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Product(\n",
       "    name='творог',\n",
       "    modifier=None\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "неповторимый вкуснейший отварной болгарский перец\n",
      "             ────────────────────────────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Product(\n",
       "    name='перец',\n",
       "    modifier=Adjs(\n",
       "        parts=['вкусный',\n",
       "         'отварный',\n",
       "         'болгарский']\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "PRODUCT = or_(\n",
    "    rule(NAME),\n",
    "    rule(NAME, MODIFIER),\n",
    "    rule(MODIFIER, NAME)\n",
    ").interpretation(\n",
    "    Product\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    PRODUCT,\n",
    "    'картофель отварной',\n",
    "    'сливочное масло',\n",
    "    'творог',\n",
    "    'неповторимый вкуснейший отварной болгарский перец'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ingredient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "700г свинины\n",
      "────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=700\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='свинина',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "скумбрия\n",
      "────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='скумбрия',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Мёд - 2 Чайных ложки\n",
      "────────────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='мёд',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Рис девзира 600 г\n",
      "─── ─────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[Ingredient(\n",
       "     measure=None,\n",
       "     product=Product(\n",
       "         name='рис',\n",
       "         modifier=None\n",
       "     )\n",
       " ),\n",
       " Ingredient(\n",
       "     measure=Measure(\n",
       "         amount=Amount(\n",
       "             value=600\n",
       "         ),\n",
       "         unit=Unit(\n",
       "             type='грамм',\n",
       "             modifier=None\n",
       "         )\n",
       "     ),\n",
       "     product=Product(\n",
       "         name='девзира',\n",
       "         modifier=None\n",
       "     )\n",
       " )]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 средне больших моркови\n",
      "         ───────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='морковь',\n",
       "        modifier=Adjs(\n",
       "            parts=['больший']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "немного чернослива\n",
      "──────────────────\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Some()\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='чернослив',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Ingredient = fact(\n",
    "    'Ingredient',\n",
    "    ['measure', 'product']\n",
    ")\n",
    "\n",
    "\n",
    "_PRODUCT = PRODUCT.interpretation(Ingredient.product)\n",
    "\n",
    "_MEASURE = MEASURE.interpretation(Ingredient.measure)\n",
    "\n",
    "SEP = in_(':-')\n",
    "\n",
    "INGREDIENT = or_(\n",
    "    rule(\n",
    "        _MEASURE,\n",
    "        SEP.optional(),\n",
    "        _PRODUCT\n",
    "    ),\n",
    "    rule(\n",
    "        _PRODUCT,\n",
    "        SEP.optional(),\n",
    "        _MEASURE\n",
    "    ),\n",
    "    _PRODUCT\n",
    ").interpretation(\n",
    "    Ingredient\n",
    ")\n",
    "\n",
    "\n",
    "show_matches(\n",
    "    INGREDIENT,\n",
    "    '700г свинины',\n",
    "    'скумбрия',\n",
    "    'Мёд - 2 Чайных ложки',\n",
    "    'Рис девзира 600 г',\n",
    "    '2 средне больших моркови',\n",
    "    'немного чернослива'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Борщ украинский \n",
      "Ингредиенты: \n",
      "кости с мясом, \n",
      "─────   ─────  \n",
      "свекла, \n",
      "──────  \n",
      "картофель, \n",
      "─────────  \n",
      "капуста свежая, \n",
      "──────────────  \n",
      "лук, \n",
      "───  \n",
      "морковь, \n",
      "───────  \n",
      "мука (важно!), \n",
      "уксус (важно!), \n",
      "томатная паста (соус), \n",
      "──────────────  ────   \n",
      "подсолнечное масло, \n",
      "──────────────────  \n",
      "чеснок, \n",
      "──────  \n",
      "перец, \n",
      "─────  \n",
      "специи. \n",
      "──────  \n",
      "Приготовление: \n",
      "1. Борщ одинаково вкусен и питателен как на мясном бульоне, так и на \n",
      "обычной воде. В первом случае отвариваем косточки с мясом полтора \n",
      "часа, не забываем снимать периодически пену с поверхности. \n",
      "2. Далее, в бульон или в обычную закипевшую воду бросаем картошку, \n",
      "нарезанную на средние кусочки, через минут 10 солим. Еще через 10 \n",
      "минут бросаем нарезанную мелкой соломкой свежую капусту. Пока все это \n",
      "хозяйство варится, готовим поджарку: красную свеклу и морковку трем на\n",
      " крупной терке (а не режем соломкой, как обычно указывается!), \n",
      "высыпаем на сковороду с подогретым подсолнечном маслом, немного тушим,\n",
      " затем добавляем туда хорошего качества густой томатный соус (не \n",
      "кетчуп) и вливаем туда немного уксуса (1 столовую ложку уксуса на 8 \n",
      "литров борща), перемешиваем и тушим еще 5 минут. Заправляем этой \n",
      "массой борщ. \n",
      "3. Далее мелко режем пару луковиц, жарим их на подсолнечном масле до \n",
      "золотистой корочки, затем добавляем туда две столовые ложки муки, \n",
      "пассеруем, если слишком густо, можно влить в сковородку пару ложек из \n",
      "варящегося борща, 1 минуту потушить и влить в кастрюлю. Добавить, если\n",
      " необходимо, еще соли, перца (черный горошком, черный молотый, \n",
      "красный, пару лавровых листиков - по вкусу все). \n",
      "4. Под конец накрошить в борщ чеснок и нарезанное мелкими кубиками \n",
      "сало без мяса. Поварить еще минут 10, выключить, накрыть крышкой и \n",
      "дать настояться не менее 4 часов (лучше всего дать борщу переночевать \n",
      "в холодильнике, а употреблять уже днем или вечером). \n",
      "Приятного аппетита!\n",
      "кости\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='кость',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "мясом\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='мясо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "свекла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='свёкла',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "картофель\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='картофель',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "капуста свежая\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='капуста',\n",
       "        modifier=Adjs(\n",
       "            parts=['свежий']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "лук\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='лук',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "морковь\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='морковь',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "томатная паста\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='паста',\n",
       "        modifier=Adjs(\n",
       "            parts=['томатный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "соус\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='соус',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "подсолнечное масло\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['подсолнечный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "чеснок\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='чеснок',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "перец\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='перец',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "специи\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='специя',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n",
      "Мягчайшие рулетики с яблоками на скорую руку.\n",
      "──────────────────   ────────                \n",
      "Долго не черствеют! \n",
      "В их основе - нежное песочное тесто на сметане, которое великолепно \n",
      "дополняет сочная и ароматная начинка из свежих яблок! Обязательно \n",
      "попробуйте! \n",
      "Ингредиенты \n",
      "Для теста \n",
      "350 г. муки \n",
      "─────────── \n",
      "200 г. сливочного масла (маргарина) \n",
      "───────────────────────  ─────────  \n",
      "200 г. сметаны \n",
      "────────────── \n",
      "2 ч.л. ванильного сахара \n",
      "──────────────────────── \n",
      "1 ч.л. разрыхлителя \n",
      "─────────────────── \n",
      "Для начинки \n",
      "4-5 яблок (средних) \n",
      "150 г. сахара (по вкусу) \n",
      "─────────────            \n",
      "2 ст.л. лимонного сока \n",
      "────────────────────── \n",
      "цедра лимона (корица, изюм и пр.) по желанию \n",
      "Приготовление \n",
      "1. В миску отправляем сливочное масло, сметану и ванильный сахар. \n",
      "Хорошо перемешиваем. \n",
      "2. Половину муки смешиваем с разрыхлителем и просеиваем к сметанно-\n",
      "масляной смеси. \n",
      "3. Начинаем замешивать тесто постепенно подсыпая оставшуюся муку (муки\n",
      " может понадобиться больше или меньше). В итоге должно получиться \n",
      "мягкое, но не липнущее к рукам тесто. \n",
      "4. Для начинки яблоки натираем на крупной терке. Добавляем лимонный \n",
      "сок, сахар и, по желанию, цедру лимона (корицу, изюм и пр.) 5. Тесто \n",
      "раскатываем в прямоугольник 15х30 см. По центру распределяем начинку \n",
      "(яблоки предварительно процедить от сока через сито) и заворачиваем \n",
      "сначала один край, затем внахлест второй. \n",
      "6. Разрезаем на кусочки шириной 4-5 см. \n",
      "7. Смазываем взболтанным яйцом (по желанию) и выпекаем в разогретой до\n",
      " 200 град. духовке до красивого румяного цвета 25-35 мин. Готовые \n",
      "рулетики по желанию посыпаем сахарной пудрой.\n",
      "Мягчайшие рулетики\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='рулетик',\n",
       "        modifier=Adjs(\n",
       "            parts=['мягкий']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "яблоками\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='яблоко',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "350 г. муки\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=350\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='мука',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 г. сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=200\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "маргарина\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='маргарин',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 г. сметаны\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=200\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сметана',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ч.л. ванильного сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=Adjs(\n",
       "            parts=['ванильный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ч.л. разрыхлителя\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='разрыхлитель',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150 г. сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=150\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ст.л. лимонного сока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='столовая'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сок',\n",
       "        modifier=Adjs(\n",
       "            parts=['лимонный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n",
      "Салат \"ШПРОТНЫЙ\" \n",
      "✏Ингредиенты:\n",
      "3-4 соленых огурца \n",
      "────────────────── \n",
      "3-4 вареных картофеля \n",
      "───────────────────── \n",
      "1 банка шпрот(желательно мелких) \n",
      "2-3 вареных яйца \n",
      "──────────────── \n",
      "Примерно 150 грамм твердого сыра ( можно и копченый колбасный сыр, с \n",
      "ним даже вкуснее получается) \n",
      "Майонез \n",
      "─────── \n",
      "1-2 ложки консервированного зеленого горошка(для украшения) \n",
      "          ──────────────────────────────────                \n",
      "✏Приготовление:\n",
      "1-й слой: резаные кубиком огурцы \n",
      "2-й слой: натертый картофель на крупной терке \n",
      "3-й слой: выкладываем шпроты целыми если они мелкие, а если крупные \n",
      "немного их разрываем и поливаем оставшимся маслом от шпрот \n",
      "4-й слой: натертый на мелкой терке желток \n",
      "5-й слой: натертый на крупной терке сыр \n",
      "6-й слой: майонез \n",
      "7-й слой: натертый на крупной терке белок \n",
      "Украсить по желанию.\n",
      "Приятного аппетита! 😉\n",
      "3-4 соленых огурца\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Range(\n",
       "                start=3,\n",
       "                stop=4\n",
       "            )\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='огурец',\n",
       "        modifier=Adjs(\n",
       "            parts=['солёный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3-4 вареных картофеля\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Range(\n",
       "                start=3,\n",
       "                stop=4\n",
       "            )\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='картофель',\n",
       "        modifier=Adjs(\n",
       "            parts=['варёный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2-3 вареных яйца\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Range(\n",
       "                start=2,\n",
       "                stop=3\n",
       "            )\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=Adjs(\n",
       "            parts=['варёный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Майонез\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='майонез',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "консервированного зеленого горошка\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='горошек',\n",
       "        modifier=Adjs(\n",
       "            parts=['консервированный',\n",
       "             'зелёный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n",
      "Рецепт «Рафаэлло»\n",
      "Ингредиенты:\n",
      "- 1 банка сгущенного молока\n",
      "  ─────────────────────────\n",
      "- 200 г сливочного масла\n",
      "  ──────────────────────\n",
      "- 200 г кокосовой стружки\n",
      "  ───────────────────────\n",
      "- 100 г миндаля\n",
      "  ─────────────\n",
      "- 1/2 пакетика ванилина.\n",
      "  ───────────────────── \n",
      "Приготовление:\n",
      "1. Размягчить масло до комнатной температуры.\n",
      "2. Смешиваем масло со сгущенным молоком.\n",
      "             ─────    ───────────────── \n",
      "3. Добавляем ванилин.\n",
      "5. Взбиваем крем миксером до тех пор, пока он не станет однородной \n",
      "массой, без крупинок.\n",
      "6. Отправляем крем в холодильник на несколько часов, чтобы он застыл.\n",
      "7. Миндаль замачиваем в воде на час. Это необходимо, чтобы снять \n",
      "кожицу.\n",
      "5. Когда крем застыл, начинаем катать конфетки, в середину вставляя \n",
      "орешек миндаля, затем обваливаем в кокосовой стружке.\n",
      "Примечание:\n",
      "Хранить домашние рафаэлло следует в холодильнике, иначе они просто \n",
      "растают. При этом не забудьте завернуть их пленкой.\n",
      "Домашние рафаэлло очень сладкие и отлично подойдут в качестве десерта \n",
      "для праздничного стола!\n",
      "1 банка сгущенного молока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='банка',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='молоко',\n",
       "        modifier=Adjs(\n",
       "            parts=['сгустить']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 г сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=200\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 г кокосовой стружки\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=200\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='стружка',\n",
       "        modifier=Adjs(\n",
       "            parts=['кокосовый']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 г миндаля\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=100\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='миндаль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/2 пакетика ванилина\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Fraction(\n",
       "                numerator=1,\n",
       "                denominator=2\n",
       "            )\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='пакетик',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='ванилин',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "масло\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сгущенным молоком\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='молоко',\n",
       "        modifier=Adjs(\n",
       "            parts=['сгустить']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n",
      "Овощная запеканка: талия скажет спасибо! \n",
      " \n",
      "Ингредиенты: \n",
      "Кабачок - 300 г \n",
      "─────────────── \n",
      "Помидор - 1 шт \n",
      "────────────── \n",
      "Лук - 1 шт \n",
      "────────── \n",
      "Морковь - 1 шт \n",
      "────────────── \n",
      "Сыр - 50 г \n",
      "────────── \n",
      "Укроп - по вкусу (любая зелень) \n",
      "────────────────  ────────────  \n",
      "Соль, перец - по вкусу \n",
      "────  ──────────────── \n",
      " \n",
      "Соус: \n",
      "────  \n",
      "Яйца - 2 шт \n",
      "─────────── \n",
      "Молоко 1% - 100 мл \n",
      "────────────────── \n",
      "Соль, перец - по вкусу \n",
      "────  ──────────────── \n",
      " \n",
      "Приготовление: \n",
      "Кабачок почистить удалить семена, порезать полукольцами тонко, лук, \n",
      "морковь, помидор полукольцами. Форму для выпекания смазать маслом, \n",
      "выложить морковь с луком, кабачок, помидор посолить, поперчить немного\n",
      " и поставить в духовку на 15 мин при 200С. Овощи зарумянятся, вытащить\n",
      " посыпать зеленью, залить соусом (яйца слегка взбить добавить молоко \n",
      "соль, перец) сверху тертый сыр и в духовку \n",
      "минут на 5-7.\n",
      "Кабачок - 300 г\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=300\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='кабачок',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Помидор - 1 шт\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='штука',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='помидор',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Лук - 1 шт\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='штука',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='лук',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Морковь - 1 шт\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='штука',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='морковь',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сыр - 50 г\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=50\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сыр',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Укроп - по вкусу\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Some()\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='укроп',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "любая зелень\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='зелень',\n",
       "        modifier=Adjs(\n",
       "            parts=['любой']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Соль\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='соль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "перец - по вкусу\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Some()\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='перец',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Соус\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='соус',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Яйца - 2 шт\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='штука',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Молоко 1% - 100 мл\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=100\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='миллилитр',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='молоко',\n",
       "        modifier=Percent(\n",
       "            value=1\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Соль\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='соль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "перец - по вкусу\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Some()\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='перец',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n",
      "ПОМИДОРЫ В СОБСТВЕННОМ СОКУ! РЕЦЕПТ НА ВЕКА! \n",
      "────────   ────────────────                  \n",
      " \n",
      "Делюсь рецептом, который передала мне бабушка через поколение! Легкое \n",
      "приготовление, а вкус просто божественный! Вся семья постоянно просит \n",
      "приготовить такие, а друзья просят рецепт! \n",
      "Очень простой и практичный рецепт, в котором найдется применение и \n",
      "крупным, и мягким, и немного придавленным помидоркам. \n",
      " \n",
      "Что понадобится для приготовления \n",
      "Крупные, спелые помидоры для сока \n",
      "         ───────────────     ──── \n",
      "Мелкие помидоры \n",
      "─────────────── \n",
      "Соль и сахар \n",
      "────   ───── \n",
      "Душистый перец-горошек \n",
      "────────────── ─────── \n",
      "Лавровый лист \n",
      "───────────── \n",
      "Гвоздика и корица (не обязательно, это на любителя) \n",
      " \n",
      "Приготовление \n",
      "Помидоры рассортируйте - крупные, мятые, мягкие помидоры пойдут на \n",
      "сок, помидоры помельче - в банки. \n",
      "Отобранные для сока помидоры прокрутите через мясорубку, вылейте сок в\n",
      " кастрюлю и поставьте на небольшой огонь. На три литра сока добавьте \n",
      "пять столовых ложек соли, шесть столовых ложек сахара, пять горошин \n",
      "душистого перца, шесть лавровых листиков. После того, как сок закипит,\n",
      " снимите пену, кипятите сок пока не перестанет образовываться пена \n",
      "(минут 12-15). \n",
      " \n",
      "Одновременно в другой кастрюле закипятите воду. В подготовленные банки\n",
      " разложите помидоры, залейте кипятком и накройте крышками. Сверху \n",
      "положите толстое полотенце. Пусть помидоры стоят пока варится томатный\n",
      " сок. Потом воду слейте, залейте помидоры кипящим соком и сразу же \n",
      "закатайте. Переверните, укутайте одеялом и оставьте до полного \n",
      "остывания. \n",
      "На 3-х литровую банку идет два килограмма помидор и литр томатного \n",
      "                           ──────────────────────        ──────────\n",
      "сока\n",
      "────\n",
      "Похожие рецепты: \n",
      "http://vk.com/wall-36888803?q=СОБСТВЕННОМ\n",
      "ПОМИДОРЫ\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='помидор',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "СОБСТВЕННОМ СОКУ\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='сок',\n",
       "        modifier=Adjs(\n",
       "            parts=['собственный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "спелые помидоры\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='помидор',\n",
       "        modifier=Adjs(\n",
       "            parts=['спелый']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='сок',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Мелкие помидоры\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='помидор',\n",
       "        modifier=Adjs(\n",
       "            parts=['мелкий']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Соль\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='соль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сахар\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Душистый перец\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='перец',\n",
       "        modifier=Adjs(\n",
       "            parts=['душистый']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "горошек\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='горошек',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Лавровый лист\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='лавровый лист',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "два килограмма помидор\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='килограмм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='помидор',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "томатного сока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='сок',\n",
       "        modifier=Adjs(\n",
       "            parts=['томатный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n",
      "Оладьи 🍓 \n",
      " \n",
      "1) ВКУСНЕЙШИЕ ПЫШНЫЕ ОЛАДЬИ \n",
      " \n",
      "ИНГРЕДИЕНТЫ: \n",
      "● 250 мл. кефира (можно взять простоквашу) \n",
      "  ──────────────              ───────────  \n",
      "● 1 яйцо \n",
      "  ────── \n",
      "● 2 ст.л. сахара \n",
      "  ────────────── \n",
      "● 2 ст.л. растопленного сливочного масла \n",
      "  ────────────────────────────────────── \n",
      "● 150 г. муки \n",
      "  ─────────── \n",
      "● 1 ч.л. ванильного сахара \n",
      "  ──────────────────────── \n",
      "● ¼ ч.л. соли \n",
      "  ─────────── \n",
      "● ¼ ч.л. соды \n",
      "  ─────────── \n",
      "● 1 ч.л. разрыхлителя \n",
      "  ─────────────────── \n",
      " \n",
      "ПРИГОТОВЛЕНИЕ: \n",
      "1. В миске смешать венчиком яйцо с сахаром и ванильным сахаром. \n",
      "2. Кефир или простоквашу немного нагреть и влить в яичную смесь. \n",
      "Добавить растопленное сливочное масло, перемешать. \n",
      "         ────────────────────────────              \n",
      "3. Муку смешать с содой, солью и разрыхлителем, просеять ее и добавить\n",
      " к жидкой массе. \n",
      "Быстрыми движениями смешать ложкой сухие и жидкие ингредиенты. Самое \n",
      "главное не вымешивать тесто (в этом и вся суть!), а только соединить \n",
      "ингредиенты. Тесто будет комками, так и нужно, не пугайтесь, комочки \n",
      "при выпечке разойдутся. Оставить тесто на 5-7 минут. \n",
      "Тесто должно быть густым (как густая сметана), из ложки на сковороду \n",
      "не течет, а падает одним комком. \n",
      "4. Хорошо нагреть сковороду, добавить растительное масло и сделать \n",
      "самый маленький огонь на вашей плите. Выложить столовую ложку теста на\n",
      " сковороду, оставляя расстояние между оладьями. \n",
      "5. Аккуратно перевернуть оладьи и обжарить с другой стороны. Жарить \n",
      "именно на маленьком огне! \n",
      "6. Готовые оладьи переложить на тарелку, дать чуть остыть и подавать \n",
      "на стол. \n",
      "7. Оладьи подавать с медом, вареньем, ягодным соусом или сметаной. \n",
      "Вкусные они и просто так, совсем не опадают, а на второй день остаются\n",
      " такими же мягкими и пышными. \n",
      " \n",
      "2) ОЛАДЬИ КАК В ШКОЛЕ \n",
      " \n",
      "ИНГРЕДИЕНТЫ: \n",
      "● Мука - 481г( 2ст. по 250мл) \n",
      "● Вода - 481г(2 ст. по 250мл минус 2ст.л.) \n",
      "● Дрожжи свежие(сырые) - 14г(сухими не заменять!!!) \n",
      "● Сахар - 17г(примерно 1 ст.л. с горкой) \n",
      "● Соль - 6г(примерно 0.5ч.л.) \n",
      "● Яйцо - 23г( у меня было крупное яйцо - пришлось взбить отдельно и \n",
      "вылить 1/3) \n",
      " \n",
      "ПРИГОТОВЛЕНИЕ: \n",
      "1. В теплой воде растворить дрожжи и сахар - дать немного постоять, \n",
      "затем добавить яйцо, соль и постепенно всыпать просеянную муку - \n",
      "перемешать лопаткой, а лучше вилкой(руками не получится - тесто \n",
      "жидкое), затем тесто накрыть крышкой или пищевой пленкой и убрать в \n",
      "теплое место на 2 часа - тесто должно подняться и запузыриться. \n",
      "2. Затем на разогретую сковороду с раст. маслом выкладывать по 1ст.л. \n",
      "теста - жарить с двух сторон до румяного цвета на среднем огне. \n",
      "3. Подавать горячие оладушки со слив. маслом или яблочным повидлом. \n",
      " \n",
      "3) БИСКВИТНЫЕ ОЛАДУШКИ \n",
      " \n",
      "ИНГРЕДИЕНТЫ: \n",
      "● Яйца - 4 шт. \n",
      "  ──────────── \n",
      "● Сахар - 1 ст. \n",
      "  ───────────── \n",
      "● Мука - 1 ст. \n",
      "  ──────────── \n",
      "● Черная смородина (у меня замороженная) - 1 ст. \n",
      "● Крахмал - 1 ст. л. \n",
      "  ────────────────── \n",
      "● Ванилин по вкусу \n",
      "  ──────────────── \n",
      " \n",
      "ПРИГОТОВЛЕНИЕ: \n",
      "1. Подготовленные и промытые и подсушенные от воды ягоды обваляйте \n",
      "слегка в муке или крахмале. \n",
      "2. Желтки отделите от белков. \n",
      "3. Белки взбейте в крепкую пену. \n",
      "4. Желтки разотрите с сахаром добела. \n",
      "5. Желтковую смесь тонкой струйкой влейте в белки, взбивая миксером. \n",
      "6. Муку смешайте с ванилином, просейте через сито и порциями \n",
      "добавляйте в смесь, осторожно перемешивая все время в одном \n",
      "направлении, чтобы не помять белковую пену. \n",
      "7. Всыпьте ягоды и еще раз аккуратно перемешайте. \n",
      "8. Жарьте как обычные оладьи на сковороде с растительным маслом, лучше\n",
      " под крышкой и на маленьком огне. \n",
      " \n",
      "4) ОЛАДЬИ НА КЕФИРЕ \n",
      " \n",
      "ИНГРЕДИЕНТЫ: \n",
      "● 500 г кефира \n",
      "  ──────────── \n",
      "● 1 яйцо \n",
      "  ────── \n",
      "● 350 г муки \n",
      "  ────────── \n",
      "● 2 ст.л. сахара \n",
      "  ────────────── \n",
      "● 1/2 ч.л. соли \n",
      "  ───────────── \n",
      "● 1/2 ч.л. соды \n",
      "  ───────────── \n",
      "● 150 г растительного масла для жарки \n",
      "  ─────────────────────────           \n",
      " \n",
      "ПРИГОТОВЛЕНИЕ: \n",
      "1. В миску вылила кефир, яйцо, добавила сахар и соль. Смешала муку с \n",
      "содой. Всыпала муку с содой в кефир. Венчиком вымешивала тесто до \n",
      "гладкости. Оставила созревать на 20 минут. \n",
      "2. Разогрела сковородку с толстым дном и налила подсолнечное масло \n",
      "высотой в 0,5 см. \n",
      "3. Огонь под сковородой очень важен. На моей электрической плите \n",
      "разогревала на 9. Затем переключила на 6. Столовой ложкой забирала \n",
      "тесто, второй ложкой снимала. \n",
      "4. Масло совсем не шипит и не горит, оладьи жарятся медленно. Когда \n",
      "верх надулся можно переворачивать. Мне удобно двумя вилками, или \n",
      "лопаткой с вилкой. \n",
      "5. Как-то я даже не была готова к такому потрясающему виду. \n",
      "6. Перевернула посмотреть вторую сторону, но этого делать не нужно, \n",
      "они и так прекрасно медленно жарятся. \n",
      "7. Иногда, когда масло слегка остывало, я включала огонь на 7, а \n",
      "затем, когда масло начинало слегка пузыриться возвращала огонь опять \n",
      "на 6. \n",
      "8. У меня большая сковорода, и я могла на ней разместить по 7 штук. \n",
      "9. Они не расплываются и легко переворачиваются. Они невозможно \n",
      "красивые, с юбочкой по краю, 2 см в высоту и воздушные как перышко. \n",
      "А какие вкусные! \n",
      " \n",
      "5) ОЛАДЬИ НА КЕФИРЕ \n",
      " \n",
      "ИНГРЕДИЕНТЫ: \n",
      "● Кефир - 0,5 л, \n",
      "  ─────────────  \n",
      "● Мука пшеничная - 350 г, \n",
      "  ──────────────────────  \n",
      "● Яйцо - 1 шт., \n",
      "  ────────────  \n",
      "● Сахар - 3 ст.ложки, \n",
      "  ──────────────────  \n",
      "● Соль - 0,5 ч.ложки, \n",
      "  ──────────────────  \n",
      "● Сода - 1 ч.ложка, \n",
      "  ────────────────  \n",
      "● Масло растительное для жарки. \n",
      "  ──────────────────            \n",
      "● Оладьи на кефире \n",
      " \n",
      "ПРИГОТОВЛЕНИЕ: \n",
      "1. Для приготовления оладий все ингредиенты должны быть комнатной \n",
      "температуры. \n",
      "2. Смешайте в одной миске муку, сахар, соль и соду. В другую миску \n",
      "разбейте яйцо, влейте кефир и хорошо перемешайте венчиком. \n",
      "3. Пересыпьте сухие ингредиенты в жидкие и венчиком перемешайте до \n",
      "получения густого однородного теста. \n",
      "4. Сковороду нагрейте и смажьте маслом. Выпекайте оладьи сразу же как \n",
      "приготовили тесто. Если у вас тефлоновая или керамическая сковорода, \n",
      "добавьте 1-2 ст.ложки растительного масла в тесто перед \n",
      "приготовлением, в этом случае сковороду смазывать маслом уже не нужно,\n",
      " оладьи не прилипнут. \n",
      "5. Подавайте оладьи со сметаной, медом, вареньем.\n",
      "Наш замечательный автор - Екатерина 😍 \n",
      " \n",
      "приятного аппетита!\n",
      "250 мл. кефира\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=250\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='миллилитр',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='кефир',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "простоквашу\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='простокваша',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 яйцо\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ст.л. сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='столовая'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ст.л. растопленного сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='столовая'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['растопить',\n",
       "             'сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150 г. муки\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=150\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='мука',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ч.л. ванильного сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=Adjs(\n",
       "            parts=['ванильный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¼ ч.л. соли\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Fraction(\n",
       "                numerator=1,\n",
       "                denominator=4\n",
       "            )\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='соль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¼ ч.л. соды\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Fraction(\n",
       "                numerator=1,\n",
       "                denominator=4\n",
       "            )\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сода',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ч.л. разрыхлителя\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='разрыхлитель',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "растопленное сливочное масло\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['растопить',\n",
       "             'сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Яйца - 4 шт.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=4\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='штука',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сахар - 1 ст.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='стакан',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Мука - 1 ст.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='стакан',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='мука',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Крахмал - 1 ст. л.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='столовая'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='крахмал',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ванилин по вкусу\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Some()\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='ванилин',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500 г кефира\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=500\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='кефир',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 яйцо\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "350 г муки\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=350\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='мука',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ст.л. сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='столовая'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/2 ч.л. соли\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Fraction(\n",
       "                numerator=1,\n",
       "                denominator=2\n",
       "            )\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='соль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/2 ч.л. соды\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Fraction(\n",
       "                numerator=1,\n",
       "                denominator=2\n",
       "            )\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сода',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150 г растительного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=150\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['растительный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Кефир - 0,5 л\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=0.5\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='литр',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='кефир',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Мука пшеничная - 350 г\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=350\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='мука',\n",
       "        modifier=Adjs(\n",
       "            parts=['пшеничный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Яйцо - 1 шт.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='штука',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сахар - 3 ст.ложки\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=3\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='столовая'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Соль - 0,5 ч.ложки\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=0.5\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='соль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сода - 1 ч.ложка\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сода',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Масло растительное\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['растительный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n",
      "Фаршированные яйца с сыром \n",
      "──────────────────   ───── \n",
      "https://kedem.ru/recipe/snack/eggch/farshirovannye-yajca-s-syrom/\n",
      "Фаршированные яйца с сыром отличная закуска на праздничный стол. \n",
      "Готовится быстро и легко. \n",
      "Ингредиенты: \n",
      "6 яиц, \n",
      "─────  \n",
      "100 г сыра, \n",
      "──────────  \n",
      "1 морковь, \n",
      "─────────  \n",
      "2 зубчика чеснока, \n",
      "─────────────────  \n",
      "2-3 ст. л. майонеза, \n",
      "───────────────────  \n",
      "1 пучок укропа, \n",
      "──────────────  \n",
      "зеленый лук, \n",
      "───────────  \n",
      "соль по вкусу. \n",
      "─────────────  \n",
      "Приготовление: \n",
      "Яйца отварить, остудить и очистить. Разрезать яйца на половинки. \n",
      "Желтки покрошить в миску. \n",
      "Добавить тертые сыр и морковь. \n",
      "         ──────────   ───────  \n",
      "Добавить майонез и прессованный чеснок. \n",
      "         ───────   ───────────────────  \n",
      "Хорошо перемешать. Посолить по вкусу. \n",
      "Выложить начинку в половинки белков. \n",
      "Украсить укропом и зеленым луком. Фаршированные яйца готовы. Можно \n",
      "подавать к праздничному столу. \n",
      "Приятного аппетита! \n",
      "#закуски #рецепты #яйца #чтоприготовить #рецептысфото #вкусныеблюда  \n",
      "#самыйвкусный\n",
      "Фаршированные яйца\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=Adjs(\n",
       "            parts=['фаршированный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сыром\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='сыр',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 яиц\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=6\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 г сыра\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=100\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сыр',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 морковь\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='морковь',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 зубчика чеснока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='зубчик',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='чеснок',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2-3 ст. л. майонеза\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Range(\n",
       "                start=2,\n",
       "                stop=3\n",
       "            )\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='столовая'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='майонез',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 пучок укропа\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='пучок',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='укроп',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "зеленый лук\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='лук',\n",
       "        modifier=Adjs(\n",
       "            parts=['зелёный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "соль по вкусу\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Some()\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='соль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "тертые сыр\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=None\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сыр',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "морковь\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='морковь',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "майонез\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='майонез',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "прессованный чеснок\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='чеснок',\n",
       "        modifier=Adjs(\n",
       "            parts=['прессовать']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n",
      "Картошка с грибами в сливках\n",
      "────────   ───────   ───────\n",
      "Ингредиенты:\n",
      "Картофель 8 шт;\n",
      "────────────── \n",
      "Грибы 400 г;\n",
      "─────────── \n",
      "Чеснок 4 зубчика;\n",
      "──────────────── \n",
      "Петрушка пучок;\n",
      "────────       \n",
      "Масло растительное 5 ст.л.;\n",
      "────────────────────────── \n",
      "Соль (морская) по вкусу;\n",
      "Чёрный перец по вкусу;\n",
      "───────────────────── \n",
      "Сливки жирные 300 мл;\n",
      "──────────────────── \n",
      "Приготовление:\n",
      "1.Время приготовления - 30 минут\n",
      "2.Разогрейте духовку до 200ᵒС. Почистите и помойте картофель, затем \n",
      "нарежьте тонкими ломтиками (2-3 мм).\n",
      "3.Хорошо промойте картошку от крахмала и оставьте стекать.\n",
      "4.Тем временем нарежьте грибы.\n",
      "5.Разогрейте масло в сковороде с толстым дном на среднем огне.\n",
      "Выложите ломтики картофеля, перемешайте деревянной ложкой, так чтобы \n",
      "все ломтики были покрыты маслом.\n",
      "Добавьте соль, перец. Продолжайте перемешивать до тех пор, пока не \n",
      "увидите, как ломтики картофеля становятся клейкими, т.к. картофель \n",
      "начинает выделять крахмал.\n",
      "6.Одновременно разогрейте сковороду для грибов, добавьте одну столовую\n",
      " ложку оливкового масла, выложите грибы и посолите.\n",
      "7.Как только ломтики картофеля становятся клейкими, добавьте чеснок и \n",
      "влейте сливки, ровно столько, сколько нужно для того, чтобы покрыть \n",
      "полностью ломтики картофеля, но не больше (как показала практика, \n",
      "можно и меньше), просто вкус будет менее жирный, но всё такой же \n",
      "насыщенный и сливочный.\n",
      "8.Убавьте огонь и готовьте картофель еще около пяти минут, пока сливки\n",
      " немного не сгустятся.\n",
      "9.Снимите с огня готовые грибы.\n",
      "10.Мелко нарежьте петрушку.\n",
      "11.Снимите сковороду с картошкой с огня и проверьте специи на вкус.\n",
      "В этот момент можно добавить соли или перца, если их количество \n",
      "кажется недостаточным.\n",
      "Вмешайте в блюдо грибы и петрушку.\n",
      "12.Переместите всё вместе в форму для выпечки. Пеките в духовке 20-30 \n",
      "минут.\n",
      "13.Блюдо готово\n",
      "Картошка\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='картошка',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "грибами\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='гриб',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сливках\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='сливки',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Картофель 8 шт\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=8\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='штука',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='картофель',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Грибы 400 г\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=400\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='гриб',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Чеснок 4 зубчика\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=4\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='зубчик',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='чеснок',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Петрушка\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='петрушка',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Масло растительное 5 ст.л.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=5\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='столовая'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['растительный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Чёрный перец по вкусу\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Some()\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='перец',\n",
       "        modifier=Adjs(\n",
       "            parts=['чёрный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сливки жирные 300 мл\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=300\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='миллилитр',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сливки',\n",
       "        modifier=Adjs(\n",
       "            parts=['жирный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n",
      "8 обалденных кремов для тортов, которые делаются в два счета\n",
      "Эти 8 кремов придадут любому десерту особый вкус и пикантность. А на \n",
      "их приготовление не уйдет много времени и сил.\n",
      "Классический заварной крем для торта\n",
      "Вам понадобятся:\n",
      "500 мл молока\n",
      "─────────────\n",
      "200 г сахара\n",
      "────────────\n",
      "1 ч. л. ванили\n",
      "──────────────\n",
      "50 г муки\n",
      "─────────\n",
      "4 яичных желтка\n",
      "───────────────\n",
      "Приготовление:\n",
      "Яичные желтки растереть с сахаром, ванилью и мукой до однородности. \n",
      "Довести молоко до кипения. Влить горячее молоко в яичную массу, \n",
      "перемешать. Полученную массу поставить на огонь и варить до \n",
      "загустения.\n",
      "Крем масляный универсальный\n",
      "Вам понадобятся:\n",
      "1 пачка сливочного масла\n",
      "────────────────────────\n",
      "4 яйца\n",
      "──────\n",
      "1 стакан сахара\n",
      "───────────────\n",
      "100 г сахарной пудры\n",
      "────────────────────\n",
      "щепотка ванили\n",
      "Приготовление:\n",
      "В кастрюлю с толстым дном разбить яйца. Перемешать их с сахаром. \n",
      "Поставить на огонь, постоянно помешивая, не отходить от плиты. Когда \n",
      "получится густая масса, убрать с огня. Перемешать массу, подождать, \n",
      "когда остынет. Взбить сливочное масло в миске с пудрой. Добавить \n",
      "яичную смесь к маслу. И щепотку ванили для вкуса. Хранить в \n",
      "холодильнике, намазывать только на остывшие коржи.\n",
      "Крем со сгущенкой и яйцами\n",
      "        ─────────   ──────\n",
      "Вам понадобятся:\n",
      "200 г сливочного масла\n",
      "──────────────────────\n",
      "100 г сгущенного молока\n",
      "───────────────────────\n",
      "2 желтка\n",
      "────────\n",
      "щепотка ванили либо 30-50 г ликера\n",
      "        ──────      ──────────────\n",
      "Приготовление:\n",
      "Размягченное сливочное масло взбить со сгущенным молоком. Продолжая \n",
      "взбивать, постепенно добавить яичные желтки. Для аромата добавить \n",
      "ваниль или другую пряность, также подойдет ликер.\n",
      "Крем из сгущенки и сливочного масла\n",
      "        ────────   ────────────────\n",
      "Вам понадобятся:\n",
      "1 банка сгущенного молока\n",
      "─────────────────────────\n",
      "1 пачка сливочного масла\n",
      "────────────────────────\n",
      "Приготовление:\n",
      "Взбить масло и молоко до однородности. Масло должно быть комнатной \n",
      "температуры. Охладить крем.\n",
      "Крем из манной каши\n",
      "        ───────────\n",
      "Вам понадобятся:\n",
      "1/2 стакана молока\n",
      "──────────────────\n",
      "1 ст. л. манной крупы\n",
      "─────────────────────\n",
      "1 ч. л. сахара\n",
      "──────────────\n",
      "1/2 ч. л. сливочного масла\n",
      "──────────────────────────\n",
      "1 желток\n",
      "────────\n",
      "1 ч. л. ванильного сахара\n",
      "─────────────────────────\n",
      "Приготовление:\n",
      "Молоко вскипятить с ванильным сахаром. Смешать манную крупу с \n",
      "небольшим количеством воды, влить полученную смесь в горячее молоко и \n",
      "довести до кипения на слабом огне. Тщательно растереть желток с \n",
      "сахаром и маслом до состояния пышной однородной массы. Добавить в нее \n",
      "манную кашу маленькими порциями, постоянно взбивая венчиком, чтобы \n",
      "крем был пышным и легким.\n",
      "Сыр-крем «Маскарпоне»\n",
      "───       ────────── \n",
      "Вам понадобятся:\n",
      "200 г творога (18%)\n",
      "─────────────      \n",
      "200 мл сливок (33%)\n",
      "─────────────      \n",
      "Приготовление:\n",
      "Творог протереть через сито (желательно дважды). Влить холодные \n",
      "сливки.\n",
      "Взбивать массу на малых оборотах до кремообразного состояния.\n",
      "Крем для эклеров\n",
      "Вам понадобятся:\n",
      "2 яйца\n",
      "──────\n",
      "1 стакан сахара\n",
      "───────────────\n",
      "1 ч. л. ванильного сахара\n",
      "─────────────────────────\n",
      "1,5 стакана молока\n",
      "──────────────────\n",
      "2 ч. л. растопленного сливочного масла\n",
      "──────────────────────────────────────\n",
      "2 ч. л. муки\n",
      "────────────\n",
      "Приготовление:\n",
      "В кастрюле смешать муку и яйца так, чтобы исчезли комочки. В другой \n",
      "кастрюле вскипятить молоко и сахар, постоянно помешивая. Влить тонкой \n",
      "струйкой молоко с сахаром в мучную смесь, интенсивно размешать \n",
      "лопаткой. Полученный крем поставить на небольшой огонь, постоянно \n",
      "помешивая, довести до загустения. Важно не дать крему закипеть!\n",
      "После этого снять крем для эклеров с огня, добавить в него ванильный \n",
      "сахар и сливочное масло. Хорошо перемешать, а затем быстро охладить,\n",
      "поставив в лед или холодную воду.\n",
      "Сливочный крем «Пятиминутка»\n",
      "Вам понадобятся:\n",
      "250 г сливочного масла\n",
      "──────────────────────\n",
      "200 г сахарной пудры\n",
      "────────────────────\n",
      "100 мл молока\n",
      "─────────────\n",
      "1 пакетик ванилина\n",
      "──────────────────\n",
      "Приготовление:\n",
      "Молоко вскипятить и остудить до комнатной температуры. Все компоненты \n",
      "соединить. Взбивать миксером до тех пор, пока масса не станет \n",
      "однородной и перламутрового цвета (примерно 3-5 минут).\n",
      "500 мл молока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=500\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='миллилитр',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='молоко',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 г сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=200\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ч. л. ванили\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='ваниль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 г муки\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=50\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='мука',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 яичных желтка\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=4\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='желток',\n",
       "        modifier=Adjs(\n",
       "            parts=['яичный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 пачка сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='упаковка',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 яйца\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=4\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 стакан сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='стакан',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 г сахарной пудры\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=100\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='пудра',\n",
       "        modifier=Adjs(\n",
       "            parts=['сахарный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сгущенкой\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='сгущёнка',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "яйцами\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 г сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=200\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 г сгущенного молока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=100\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='молоко',\n",
       "        modifier=Adjs(\n",
       "            parts=['сгустить']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 желтка\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='желток',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ванили\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='ваниль',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30-50 г ликера\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Range(\n",
       "                start=30,\n",
       "                stop=50\n",
       "            )\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='ликёр',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сгущенки\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='сгущёнка',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 банка сгущенного молока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='банка',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='молоко',\n",
       "        modifier=Adjs(\n",
       "            parts=['сгустить']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 пачка сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='упаковка',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "манной каши\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='каша',\n",
       "        modifier=Adjs(\n",
       "            parts=['манный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/2 стакана молока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Fraction(\n",
       "                numerator=1,\n",
       "                denominator=2\n",
       "            )\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='стакан',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='молоко',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ст. л. манной крупы\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='столовая'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='крупа',\n",
       "        modifier=Adjs(\n",
       "            parts=['манный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ч. л. сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/2 ч. л. сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=Fraction(\n",
       "                numerator=1,\n",
       "                denominator=2\n",
       "            )\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 желток\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='желток',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ч. л. ванильного сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=Adjs(\n",
       "            parts=['ванильный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сыр\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='сыр',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Маскарпоне\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=None,\n",
       "    product=Product(\n",
       "        name='маскарпоне',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 г творога\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=200\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='творог',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 мл сливок\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=200\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='миллилитр',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сливки',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 яйца\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=None\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='яйцо',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 стакан сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='стакан',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ч. л. ванильного сахара\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='сахар',\n",
       "        modifier=Adjs(\n",
       "            parts=['ванильный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,5 стакана молока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1.5\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='стакан',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='молоко',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ч. л. растопленного сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['растопить',\n",
       "             'сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ч. л. муки\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=2\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type=Spoon(\n",
       "                type='чайная'\n",
       "            ),\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='мука',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "250 г сливочного масла\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=250\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='масло',\n",
       "        modifier=Adjs(\n",
       "            parts=['сливочный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200 г сахарной пудры\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=200\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='грамм',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='пудра',\n",
       "        modifier=Adjs(\n",
       "            parts=['сахарный']\n",
       "        )\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 мл молока\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=100\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='миллилитр',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='молоко',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 пакетик ванилина\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Ingredient(\n",
       "    measure=Measure(\n",
       "        amount=Amount(\n",
       "            value=1\n",
       "        ),\n",
       "        unit=Unit(\n",
       "            type='пакетик',\n",
       "            modifier=None\n",
       "        )\n",
       "    ),\n",
       "    product=Product(\n",
       "        name='ванилин',\n",
       "        modifier=None\n",
       "    )\n",
       ")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==============================\n"
     ]
    }
   ],
   "source": [
    "from yargy.span import Span\n",
    "\n",
    "\n",
    "class Line(Record):\n",
    "    __attributes__ = ['offset', 'text']\n",
    "\n",
    "    def __init__(self, offset, text):\n",
    "        self.offset = offset\n",
    "        self.text = text\n",
    "\n",
    "\n",
    "class Match(Record):\n",
    "    __attributes__ = ['span', 'fact']\n",
    "\n",
    "    def __init__(self, span, fact):\n",
    "        self.span = span\n",
    "        self.fact = fact\n",
    "\n",
    "\n",
    "class Result(Record):\n",
    "    __attributes__ = ['text', 'matches']\n",
    "\n",
    "    def __init__(self, text, matches):\n",
    "        self.text = text\n",
    "        self.matches = matches\n",
    "\n",
    "\n",
    "def get_coverage(line, spans):\n",
    "    cover = 0\n",
    "    for start, stop in spans:\n",
    "        cover += stop - start\n",
    "    return cover / len(line)\n",
    "\n",
    "\n",
    "def get_lines(text):\n",
    "    for match in re.finditer('[^\\n]+', text):\n",
    "        yield Line(\n",
    "            match.start(),\n",
    "            match.group(0)\n",
    "        )\n",
    "\n",
    "\n",
    "def offset_span(span, offset):\n",
    "    return Span(\n",
    "        span.start + offset,\n",
    "        span.stop + offset\n",
    "    )\n",
    "\n",
    "\n",
    "class Extractor(object):\n",
    "    def __init__(self):\n",
    "        self.parser = Parser(INGREDIENT)\n",
    "\n",
    "    def process(self, line):\n",
    "        matches = self.parser.findall(line.text)\n",
    "        matches = sorted(matches, key=lambda _: _.span)\n",
    "        spans = [_.span for _ in matches]\n",
    "        coverage = get_coverage(line.text, spans)\n",
    "        if coverage > 0.5:\n",
    "            for match in matches:\n",
    "                span = offset_span(match.span, line.offset)\n",
    "                yield Match(span, match.fact)\n",
    "\n",
    "    def __call__(self, text):\n",
    "        text = preprocess(text)\n",
    "        matches = []\n",
    "        for line in get_lines(text):\n",
    "            matches.extend(self.process(line))\n",
    "        return Result(text, matches)\n",
    "\n",
    "    \n",
    "extractor = Extractor()\n",
    "seed(12)\n",
    "for text in sample(texts, 10):\n",
    "    result = extractor(text)\n",
    "    show_markup(result.text, [_.span for _ in result.matches])\n",
    "    for match in result.matches:\n",
    "        start, stop = match.span\n",
    "        print(result.text[start:stop])\n",
    "        display(match.fact)\n",
    "    print('===' * 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
